home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 2 / Atari Mega Archive CD - Volume 2.iso / minix / up1510b.tgz / up1510b / src / commands / atari / format.c < prev    next >
C/C++ Source or Header  |  1990-07-15  |  5KB  |  260 lines
  1. /* format.c: format a floppy disk */
  2.  
  3. /* Author:  Gary Mills <mills@ccu.umanitoba.ca> */
  4. /* adapted for HAVENEWFLOP by Howard Johnson */
  5.  
  6. #include <stdio.h>
  7. #include <minix/const.h>
  8.  
  9. #define TRACK_SIZE    7168
  10. #define NR_SECTORS    9
  11. #define NR_CYLINDERS    80
  12. #define TRACK_CAP    (512*NR_SECTORS)
  13. #define TRK_NDX        3
  14.  
  15.  
  16. struct desc {
  17.     int rep;    /* repetition count */
  18.     int val;    /* byte value */
  19. };
  20. typedef struct desc DESC;
  21.  
  22. DESC leader[] = {
  23.     160,    0x4e,    /* pre-index gap */
  24.     12,    0,    /* sync before index */
  25.     3,    0xf6,    /* C2 */
  26.     1,    0xfc,    /* index mark */
  27.     80,    0xff,    /* gap 1 */
  28.     0,    0
  29. };
  30.  
  31. DESC brack[] = {
  32.     12,    0,    /* sync before id */
  33.     3,    0xf5,    /* A1 */
  34.     1,    0xfe,    /* id address mark */
  35.     1,    0,    /* track */
  36.     1,    0,    /* side */
  37.     1,    0,    /* sector */
  38.     1,    2,    /* sector length (512) */
  39.     1,    0xf7,    /* crc */
  40.     22,    0x4e,    /* gap 2 */
  41.     12,    0,    /* sync before data */
  42.     3,    0xf5,    /* A1 */
  43.     1,    0xfb,    /* data address mark */
  44.     512,    0,    /* data */
  45.     1,    0xf7,    /* crc */
  46.     64,    0x4e,    /* gap 3 */
  47.     0,    0
  48. };
  49.  
  50. DESC trail[] = {
  51.     TRACK_SIZE,    0x4e,    /* gap */
  52.     0,    0
  53. };
  54.  
  55. int interleave[NR_SECTORS] = { 1,6,2,7,3,8,4,9,5 };
  56. int verbose = 1;
  57.  
  58. int nr_heads;
  59. int o_trk, b_len;
  60. char *mark;
  61. short disk;
  62. char image[TRACK_SIZE];
  63. char b_dev[128], f_dev[128], c_dev[128];
  64.  
  65. char *strrchr();
  66. char *fill();
  67.  
  68. /*
  69.  * Block 0 of a TOS media    -- from tos.c
  70.  *    (media : floppy diskette or hard disk partion)
  71.  * Contains media description and boot code
  72.  */
  73. struct block0 {
  74.     char    b0_res0[8];
  75.     char    b0_serial[3];
  76.     char    b0_bps[2];
  77.     char    b0_spc;
  78.     char    b0_res[2];
  79.     char    b0_nfats;
  80.     char    b0_ndirs[2];
  81.     char    b0_nsects[2];
  82.     char    b0_media;
  83.     char    b0_spf[2];
  84.     char    b0_spt[2];
  85.     char    b0_nsides[2];
  86.     char    b0_nhid[2];
  87.     char    b0_code[0x1e2];
  88. };
  89. struct    block0    block0 = {
  90.     0,0,'T','O','S',' ',' ',' ',
  91.     'M','I','X', 0,2,  2,  1,0,    /* serial,bps,spc,res */
  92.     2,  0x70,0,  0xa0,5, 0xf9, 5,0, /* nfats,ndirs,nsects,media,spf */
  93.     NR_SECTORS,0, 2,0, 0,0    /* spt, nsides,nhid */
  94. };
  95.  
  96. /* convert an 88-format short into a 68-format short */
  97. #define    sh88tosh68(ch)    ((short)(((ch)[1]<<8)|(ch)[0]))
  98.  
  99.  
  100. main(argc, argv) int argc; char *argv[]; {
  101.     char *drive;
  102.     char *pt;
  103.     int n,i;
  104.     int head, cyl;
  105.  
  106.     if ( argc != 2 ) {
  107.         fprintf(stderr, "Usage: format drive\n");
  108.         exit(1);
  109.     }
  110.     drive = argv[1];
  111.     if ( *drive >= '0' && *drive <= '9' )
  112.         sprintf(b_dev, "/dev/fd%c", *drive);
  113.     else if ( *drive == '/' )
  114.         strcpy(b_dev, drive);
  115.     else
  116.         sprintf(b_dev, "/dev/%s", drive);
  117.     strcpy(f_dev, b_dev);
  118.     strcpy(c_dev, b_dev);
  119.     if ( !( pt = strrchr(b_dev, '/') ) ) {
  120.         fprintf(stderr, "Invalid drive %s\n", drive);
  121.         exit(1);
  122.     }
  123.     ++pt;
  124.     sprintf(f_dev + (pt - b_dev), "fmt%s", pt);
  125.     sprintf(c_dev + (pt - b_dev), "r%s", pt);
  126.     if ( *pt == 'f' )
  127.         nr_heads = 1;
  128.     else if ( *pt == 'd' )
  129.         nr_heads = 2;
  130.     else {
  131.         fprintf(stderr, "Invalid drive %s\n", drive);
  132.         exit(1);
  133.     }
  134.  
  135.     b_len = 0;
  136.     for ( n = 0; brack[n].rep; ++n ) {
  137.         if ( n == TRK_NDX )
  138.             o_trk = b_len;
  139.         b_len += brack[n].rep;
  140.     }
  141.  
  142.     pt = fill(image, &leader[0]);
  143.     mark = pt + o_trk;
  144.     for ( n = 0; n < NR_SECTORS; ++n )
  145.         pt = fill(pt, &brack[0]);
  146.     fill(pt, &trail[0]);
  147.  
  148.     if ( ( disk = open(f_dev, 1) ) < 0 ) {
  149.         fprintf(stderr, "Cannot open %s\n", f_dev);
  150.         exit(1);
  151.     }
  152.     if ( verbose ) 
  153.         fprintf(stderr, "Formatting\n");
  154.     for ( cyl = 0; cyl < NR_CYLINDERS; ++cyl ) {
  155.         if ( verbose )
  156.             fprintf(stderr, "Cyl: %d\r", cyl);
  157.         for ( head = 0; head < nr_heads; ++head ) {
  158.             pt = mark;
  159.             for ( n = 0; n < NR_SECTORS; ++n ) {
  160.                 pt[0] = cyl;
  161.                 pt[1] = head;
  162.                 pt[2] = interleave[n];
  163.                 pt += b_len;
  164.             }
  165.             if ( write(disk, image, TRACK_SIZE) != TRACK_SIZE ) {
  166.                 extern int errno;
  167.                 perror("I/O Error");
  168.                 fprintf(stderr,"errno=%d on cyl=%d\n",errno,cyl);
  169.                 exit(1);
  170.             }
  171.         }
  172.     }
  173.     close(disk);
  174.  
  175.     if ( ( disk = open(c_dev, 2) ) < 0 ) {
  176.         fprintf(stderr, "Cannot open %s\n", c_dev);
  177.         exit(1);
  178.     }
  179.   /* Fix the boot block up.... */
  180.  
  181.  i = NR_SECTORS * NR_CYLINDERS * nr_heads;
  182.  block0.b0_nsects[0] = i ;
  183.  block0.b0_nsects[1] = i >> 8;
  184.  block0.b0_nsides[0] = nr_heads ;
  185.  block0.b0_nsides[1] = nr_heads >> 8;
  186. /*
  187.   bzero(block0.b0_code, sizeof(block0.b0_code) + sizeof(buf));
  188.  */
  189.     for(i=0;i<sizeof(block0.b0_code);i++)
  190.         block0.b0_code[i] = 0;
  191.  
  192.  
  193.     if ( write(disk, &block0, sizeof(block0)) != sizeof(block0) ) {
  194.         fprintf(stderr, "Error writing sector 0 \n");
  195.         exit(1);
  196.     }
  197.     lseek(disk,0L,0);
  198.     if ( read(disk, image, sizeof(block0)) != sizeof(block0) ) {
  199.         fprintf(stderr, "Error reading sector 0 \n");
  200.         exit(1);
  201.     }
  202.     for(i=0;i<sizeof(block0);i++) {
  203.         if( ((char*)&block0)[i] !=  ((char*)image)[i]) {
  204.             fprintf(stderr, "Block 0 differs a byte %d %x != %x\n",
  205.                 i,((char*)&block0)[i],((char*)image)[i]);
  206.             exit(1);
  207.         }
  208.     }
  209.     close(disk);
  210.  
  211.     if ( ( disk = open(c_dev, 0) ) < 0 ) {
  212.         fprintf(stderr, "Cannot open %s\n", c_dev);
  213.         exit(1);
  214.     }
  215.     if ( verbose )
  216.         fprintf(stderr, "Verifying \n");
  217.     for ( cyl = 0; cyl < NR_CYLINDERS; ++cyl ) {
  218.         if ( verbose )
  219.             fprintf(stderr, "Cyl: %d\r", cyl);
  220.         for ( head = 0; head < nr_heads; ++head ) {
  221.             if ( read(disk, image, TRACK_CAP) != TRACK_CAP ) {
  222.                 fprintf(stderr, "Error reading cylinder %d\n", cyl);
  223.                 exit(1);
  224.             }
  225.         }
  226.     }
  227.     close(disk);
  228.     if ( verbose )
  229.         fprintf(stderr, "Complete   \n");
  230.  
  231.     exit(0);
  232. }
  233.  
  234. char *
  235. fill(pt, st) char *pt; DESC *st; {
  236.     char *lim = &image[TRACK_SIZE];
  237.     register int n;
  238.  
  239.     while ( (n = st->rep ) && pt < lim ) {
  240.         while ( --n >= 0 && pt < lim ) 
  241.             *pt++ = st->val;
  242.         ++st;
  243.     }
  244.     return pt;
  245. }
  246.  
  247. char *
  248. strrchr(s, c) char *s, c; {
  249.     register char *pt = NULL;
  250.     while ( *s ) {
  251.         if ( c == *s )
  252.             pt = s;
  253.         ++s;
  254.     }
  255.     return pt;
  256. }
  257.  
  258. /**/
  259.  
  260.